Express.js Middleware: Edistyneiden käytäntöjen hallinta skaalautuvia sovelluksia varten

Express.js, nopea, mielipiteetön, minimalistinen web-kehys Node.js:lle, on kulmakivi verkkosovellusten ja API:en rakentamisessa. Sen ytimessä on tehokas middleware-käsite. Tämä blogikirjoitus syventyy edistyneisiin middleware-käytäntöihin ja tarjoaa sinulle tiedon ja käytännön esimerkkejä kestävien, skaalautuvien ja ylläpidettävien sovellusten luomiseen, jotka soveltuvat globaalille yleisölle. Tutustumme tekniikoihin virheidenkäsittelyyn, autentikointiin, auktorisointiin, nopeusrajoitukseen ja muihin nykyaikaisten verkkosovellusten rakentamisen kriittisiin osa-alueisiin.

Middleware-käsitteen ymmärtäminen: Perusta

Express.js:n middleware-funktiot ovat funktioita, joilla on pääsy pyyntöobjektiin (req), vastausobjektiin (res) ja sovelluksen pyyntö-vastaus-syklin seuraavaan middleware-funktioon. Middleware-funktiot voivat suorittaa monenlaisia tehtäviä, kuten:

• Minkä tahansa koodin suorittaminen.
• Muutosten tekeminen pyyntö- ja vastausobjekteihin.
• Pyyntö-vastaus-syklin lopettaminen.
• Seuraavan middleware-funktion kutsuminen pinossa.

Middleware on pohjimmiltaan putki. Jokainen middleware-osa suorittaa oman tehtävänsä ja sitten valinnaisesti välittää ohjauksen seuraavalle middleware-osalle ketjussa. Tämä modulaarinen lähestymistapa edistää koodin uudelleenkäyttöä, vastuualueiden erottamista ja selkeämpää sovellusarkkitehtuuria.

Middleware-rakenteen anatomia

Tyypillinen middleware-funktio noudattaa tätä rakennetta:

            function myMiddleware(req, res, next) {
  // Suorita toimenpiteitä
  // Esimerkki: Kirjaa pyyntötiedot
  console.log(`Request: ${req.method} ${req.url}`);

  // Kutsu seuraavaa middlewarea pinossa
  next();
}

            

              
                Copy
              
            
          

next()-funktio on ratkaisevan tärkeä. Se signaloi Express.js:lle, että nykyinen middleware on saanut tehtävänsä valmiiksi ja ohjaus tulisi välittää seuraavalle middleware-funktiolle. Jos next()-funktiota ei kutsuta, pyyntö pysähtyy eikä vastausta koskaan lähetetä.

Middleware-tyypit

Express.js tarjoaa useita middleware-tyyppejä, joista jokaisella on oma erillinen tarkoituksensa:

• Sovellustason middleware: Käytetään kaikilla reiteillä tai tietyillä reiteillä.
• Reititin-tason middleware: Käytetään reitittimen instanssiin määritellyillä reiteillä.
• Virheidenkäsittely-middleware: Suunniteltu erityisesti virheiden käsittelyyn. Sijoitetaan *reittimääritysten jälkeen* middleware-pinossa.
• Sisäänrakennettu middleware: Express.js:n mukana tulevat (esim. express.static staattisten tiedostojen tarjoiluun).
• Kolmannen osapuolen middleware: Asennetaan npm-paketeista (esim. body-parser, cookie-parser).

Edistyneet middleware-mallit

Tutustutaanpa edistyneisiin malleihin, jotka voivat merkittävästi parantaa Express.js-sovelluksesi toiminnallisuutta, tietoturvaa ja ylläpidettävyyttä.

1. Virheidenkäsittely-middleware

Tehokas virheidenkäsittely on ensiarvoisen tärkeää luotettavien sovellusten rakentamisessa. Express.js tarjoaa erillisen virheidenkäsittely-middleware-funktion, joka sijoitetaan viimeiseksi middleware-pinossa. Tämä funktio ottaa neljä argumenttia: (err, req, res, next).

Tässä esimerkki:

            // Virheidenkäsittely-middleware
app.use((err, req, res, next) => {
  console.error(err.stack); // Kirjaa virhe virheenkorjausta varten
  res.status(500).send('Jokin meni vikaan!'); // Vastaa asianmukaisella tilakoodilla
});

            

              
                Copy
              
            
          

Keskeisiä huomioita virheidenkäsittelyssä:

• Virheiden kirjaaminen: Käytä kirjaamisohjelmistoa (esim. Winston, Bunyan) virheiden tallentamiseen virheenkorjausta ja seurantaa varten. Harkitse eri vakavuusasteiden kirjaamista (esim. error, warn, info, debug)
• Tilakoodit: Palauta asianmukaiset HTTP-tilakoodit (esim. 400 Bad Request, 401 Unauthorized, 500 Internal Server Error) virheen luonteen ilmoittamiseksi asiakkaalle.
• Virheviestit: Tarjoa asiakkaalle informatiivisia, mutta turvallisia, virheviestjä. Vältä arkaluonteisten tietojen paljastamista vastauksessa. Harkitse yksilöllisen virhekoodin käyttöä ongelmien sisäiseen seurantaan samalla kun palautat yleisen viestin käyttäjälle.
• Keskitetty virheidenkäsittely: Ryhmittele virheidenkäsittely erilliseen middleware-funktioon paremman organisoinnin ja ylläpidettävyyden vuoksi. Luo mukautettuja virheluokkia eri virhetilanteisiin.

2. Autentikointi- ja auktorisointi-middleware

API:n suojaaminen ja arkaluonteisten tietojen suojaaminen on ensiarvoisen tärkeää. Autentikointi varmistaa käyttäjän identiteetin, kun taas auktorisointi määrittää, mitä käyttäjällä on oikeus tehdä.

Autentikointistrategiat:

• JSON Web Tokens (JWT): Suosittu tilaton autentikointimenetelmä, joka soveltuu API:lle. Palvelin myöntää JWT:n asiakkaalle onnistuneen kirjautumisen jälkeen. Asiakas sisällyttää tämän tunnuksen myöhempiin pyyntöihin. Kirjastot kuten jsonwebtoken ovat yleisesti käytettyjä.
• Sessiot: Säilytä käyttäjäistuntoja evästeiden avulla. Tämä sopii verkkosovelluksiin, mutta voi olla vähemmän skaalautuva kuin JWT:t. Kirjastot kuten express-session helpottavat istunnon hallintaa.
• OAuth 2.0: Laajasti omaksuttu standardi valtuutetulle auktorisoinnille, joka antaa käyttäjille mahdollisuuden myöntää pääsyn resursseihinsa jakamatta suoraan tunnuksiaan. (esim. kirjautuminen Googlen, Facebookin jne. kautta). Toteuta OAuth-virta käyttämällä kirjastoja kuten passport.js tiettyjen OAuth-strategioiden kanssa.

Auktorisointistrategiat:

• Rooliperusteinen pääsynhallinta (RBAC): Määritä roolit (esim. admin, editori, käyttäjä) käyttäjille ja myönnä oikeuksia näiden roolien perusteella.
• Attribuuttiperusteinen pääsynhallinta (ABAC): Joustavampi lähestymistapa, joka käyttää käyttäjän, resurssin ja ympäristön attribuutteja pääsyn määrittämiseen.

Esimerkki (JWT-autentikointi):

            const jwt = require('jsonwebtoken');
const secretKey = 'YOUR_SECRET_KEY'; // Korvaa vahvalla, ympäristömuuttujista johdetulla avaimella

// Middleware JWT-tunnusten varmentamiseen
function authenticateToken(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];

  if (token == null) return res.sendStatus(401); // Luvaton

  jwt.verify(token, secretKey, (err, user) => {
    if (err) return res.sendStatus(403); // Kielletty
    req.user = user; // Liitä käyttäjätiedot pyyntöön
    next();
  });
}

// Esimerkkireitti, jota suojaa autentikointi
app.get('/profile', authenticateToken, (req, res) => {
  res.json({ message: `Tervetuloa, ${req.user.username}` });
});

            

              
                Copy
              
            
          

Tärkeitä turvallisuushuomioita:

• Tunnusten turvallinen säilytys: Älä koskaan säilytä salasanoja selväkielisenä. Käytä vahvoja salasanojen tiivistysalgoritmeja, kuten bcrypt tai Argon2.
• HTTPS: Käytä aina HTTPS:ää asiakkaan ja palvelimen välisen tiedonsiirron salaamiseen.
• Syötteen validointi: Validoi kaikki käyttäjän syötteet turvallisuusaukkojen, kuten SQL-injektion ja cross-site scripting (XSS) estämiseksi.
• Säännölliset turvallisuustarkastukset: Suorita säännöllisiä turvallisuustarkastuksia mahdollisten haavoittuvuuksien tunnistamiseksi ja korjaamiseksi.
• Ympäristömuuttujat: Säilytä arkaluonteiset tiedot (API-avaimet, tietokantatunnukset, salaiset avaimet) ympäristömuuttujina sen sijaan, että upottaisit ne koodiisi. Tämä helpottaa konfiguraation hallintaa ja edistää parhaita turvallisuuskäytäntöjä.

3. Nopeusrajoitus-middleware

Nopeusrajoitus suojaa APIasi väärinkäytöltä, kuten palvelunestohyökkäyksiltä (DoS) ja liialliselta resurssien kulutukselta. Se rajoittaa pyyntöjen määrää, jonka asiakas voi tehdä tietyn ajanjakson aikana.

Kirjastot kuten express-rate-limit ovat yleisesti käytettyjä nopeusrajoituksessa. Harkitse myös pakettia helmet, joka sisältää perusnopeusrajoitusominaisuuden lisäksi joukon muita turvallisuuden parannuksia.

Esimerkki (Käyttäen express-rate-limit):

            const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minuuttia
  max: 100, // Rajoita jokaista IP-osoitetta 100 pyyntöön per windowMs
  message: 'Liian monta pyyntöä tältä IP-osoitteelta, yritä uudelleen 15 minuutin kuluttua',
});

// Käytä nopeusrajoitinta tietyissä reiteissä
app.use('/api/', limiter);

// Vaihtoehtoisesti, käytä kaikissa reiteissä (yleensä vähemmän toivottavaa, ellei kaikkea liikennettä pidä käsitellä samalla tavalla)
// app.use(limiter);

            

              
                Copy
              
            
          

Nopeusrajoituksen mukautusvaihtoehtoja ovat:

• IP-osoiteperusteinen nopeusrajoitus: Yleisin lähestymistapa.
• Käyttäjäperusteinen nopeusrajoitus: Vaatii käyttäjän autentikointia.
• Pyyntömenetelmäperusteinen nopeusrajoitus: Rajoita tiettyjä HTTP-menetelmiä (esim. POST-pyynnöt).
• Mukautettu tallennus: Tallenna nopeusrajoitustiedot tietokantaan (esim. Redis, MongoDB) parempaa skaalautuvuutta varten useiden palvelininstanssien välillä.

4. Pyyntö-body-jäsennyksen middleware

Express.js ei oletusarvoisesti jäsenennä pyyntö-bodya. Tarvitset middlewarea käsitelläksesi eri body-muotoja, kuten JSON ja URL-koodatut tiedot. Vaikka vanhemmat toteutukset ovat saattaneet käyttää paketteja kuten `body-parser`, nykyinen paras käytäntö on käyttää Expressin sisäänrakennettua middlewarea, kuten se on saatavilla Express v4.16:sta lähtien.

Esimerkki (Sisäänrakennetun middlewaren käyttö):

            app.use(express.json()); // Jäsentää JSON-koodatut pyyntö-bodyt
app.use(express.urlencoded({ extended: true })); // Jäsentää URL-koodatut pyyntö-bodyt

            

              
                Copy
              
            
          

express.json()-middleware jäsentää saapuvat pyynnöt JSON-sisällöillä ja tekee jäsennellyn datan saataville `req.body`:ssa. express.urlencoded()-middleware jäsentää saapuvat pyynnöt URL-koodatuilla sisällöillä. { extended: true }-optio sallii rikkaiden objektien ja taulukoiden jäsennyksen.

5. Kirjaamis-middleware

Tehokas kirjaaminen on välttämätöntä sovelluksesi virheenkorjauksessa, seurannassa ja tarkastuksessa. Middleware voi siepata pyyntöjä ja vastauksia kirjataksen asianmukaiset tiedot.

Esimerkki (Yksinkertainen kirjaamis-middleware):

            const morgan = require('morgan'); // Suosittu HTTP-pyyntöjen kirjaaja

app.use(morgan('dev')); // Kirjaa pyynnöt 'dev'-muodossa

// Toinen esimerkki, mukautettu muotoilu
app.use((req, res, next) => {
  console.log(`${req.method} ${req.url} - ${new Date().toISOString()}`);
  next();
});

            

              
                Copy
              
            
          

Tuotantoympäristöissä harkitse järeämmän kirjaamisohjelmiston käyttöä (esim. Winston, Bunyan) seuraavilla ominaisuuksilla:

• Kirjaamistasot: Käytä erilaisia kirjaamistasoja (esim. debug, info, warn, error) lokiviestien luokitteluun niiden vakavuuden perusteella.
• Lokien kierto: Toteuta lokien kierto lokitiedostojen koon hallitsemiseksi ja levytilan ongelmien estämiseksi.
• Keskitetty kirjaaminen: Lähetä lokit keskitettyyn kirjaamispalveluun (esim. ELK-pinon (Elasticsearch, Logstash, Kibana), Splunk) helpompaa seurantaa ja analysointia varten.

6. Pyyntöjen validointi-middleware

Validoi saapuvat pyynnöt datan eheyden varmistamiseksi ja odottamattoman käyttäytymisen estämiseksi. Tämä voi sisältää pyyntöotsikoiden, kyselyparametrien ja pyyntö-body-datan validoinnin.

Kirjastot pyyntöjen validointiin:

• Joi: Tehokas ja joustava validointikirjasto skeemojen määrittelyyn ja datan validointiin.
• Ajv: Nopea JSON-skeeman validoija.
• Express-validator: Joukko express-middlewareja, jotka kietovat validator.js:n helppokäyttöisyyttä varten Expressin kanssa.

Esimerkki (Joi:n käyttö):

            const Joi = require('joi');

const userSchema = Joi.object({
  username: Joi.string().min(3).max(30).required(),
  email: Joi.string().email().required(),
  password: Joi.string().min(6).required(),
});

function validateUser(req, res, next) {
  const { error } = userSchema.validate(req.body, { abortEarly: false }); // Aseta abortEarly arvoon false saadaksesi kaikki virheet

  if (error) {
    return res.status(400).json({ errors: error.details.map(err => err.message) }); // Palauta yksityiskohtaiset virheilmoitukset
  }

  next();
}

app.post('/users', validateUser, (req, res) => {
  // Käyttäjätiedot ovat kelvollisia, jatka käyttäjän luomista
  res.status(201).json({ message: 'Käyttäjä luotu onnistuneesti' });
});

            

              
                Copy
              
            
          

Parhaat käytännöt pyyntöjen validointiin:

• Skeemaperusteinen validointi: Määritä skeemat datasi odotetun rakenteen ja datatyyppien määrittämiseksi.
• Virheidenkäsittely: Palauta informatiiviset virheilmoitukset asiakkaalle, kun validointi epäonnistuu.
• Syötteen puhdistus: Puhdista käyttäjän syöte estääksesi haavoittuvuudet, kuten cross-site scripting (XSS). Vaikka syötteen validointi keskittyy siihen, *mikä* on hyväksyttävää, puhdistus keskittyy siihen, *miten* syöte esitetään haitallisten elementtien poistamiseksi.
• Keskitetty validointi: Luo uudelleenkäytettäviä validointi-middleware-funktioita koodin päällekkäisyyden välttämiseksi.

7. Vastausten pakkaus-middleware

Paranna sovelluksesi suorituskykyä pakkaamalla vastaukset ennen niiden lähettämistä asiakkaalle. Tämä vähentää siirrettävän datan määrää, mikä johtaa nopeampiin latausaikoihin.

Esimerkki (compression-middlewaren käyttö):

            const compression = require('compression');

app.use(compression()); // Ota käyttöön vastausten pakkaus (esim. gzip)

            

              
                Copy
              
            
          

compression-middleware pakkaa automaattisesti vastaukset käyttäen gzip- tai deflate-menetelmää asiakkaan Accept-Encoding-otsikon perusteella. Tämä on erityisen hyödyllistä staattisten resurssien ja suurten JSON-vastausten tarjoilussa.

8. CORS (Cross-Origin Resource Sharing) Middleware

Jos API:si tai verkkosovelluksesi tarvitsee hyväksyä pyyntöjä eri verkkotunnuksista (alkuperä), sinun on määritettävä CORS. Tämä edellyttää asianmukaisten HTTP-otsikoiden asettamista cross-origin-pyyntöjen sallimiseksi.

Esimerkki (CORS-middlewaren käyttö):

            const cors = require('cors');

const corsOptions = {
  origin: 'https://your-allowed-domain.com',
  methods: 'GET,POST,PUT,DELETE',
  allowedHeaders: 'Content-Type,Authorization'
};

app.use(cors(corsOptions));

// TAI sallimaan kaikki alkuperät (kehitykseen tai sisäisiin API:hin -- käytä varoen!)
// app.use(cors());

            

              
                Copy
              
            
          

Tärkeitä huomioita CORS:iin liittyen:

• Alkuperä: Määritä sallitut alkuperät (verkkotunnukset) luvattoman käytön estämiseksi. Yleensä on turvallisempaa sallia tietyt alkuperät kuin sallia kaikki alkuperät (*).
• Menetelmät: Määritä sallitut HTTP-menetelmät (esim. GET, POST, PUT, DELETE).
• Otsikot: Määritä sallitut pyyntöotsikot.
• Esitarkastuspyynnöt: Monimutkaisissa pyynnöissä (esim. mukautetuilla otsikoilla tai muilla kuin GET, POST, HEAD-menetelmillä) selain lähettää esitarkastuspyynnön (OPTIONS) tarkistaakseen, onko varsinainen pyyntö sallittu. Palvelimen on vastattava asianmukaisilla CORS-otsikoilla, jotta esitarkastuspyyntö onnistuu.

9. Staattisten tiedostojen tarjoilu

Express.js tarjoaa sisäänrakennetun middlewaren staattisten tiedostojen (esim. HTML, CSS, JavaScript, kuvat) tarjoiluun. Tätä käytetään tyypillisesti sovelluksesi etupään tarjoiluun.

Esimerkki (express.staticin käyttö):

            app.use(express.static('public')); // Tarjoile tiedostoja 'public'-hakemistosta

            

              
                Copy
              
            
          

Sijoita staattiset resurssisi public-hakemistoon (tai johon tahansa muuhun määrittämääsi hakemistoon). Express.js tarjoilee nämä tiedostot sitten automaattisesti tiedostopolkujensa perusteella.

10. Mukautettu middleware erityistehtäviin

Käsiteltujen mallien lisäksi voit luoda mukautettuja middlewareja, jotka on räätälöity sovelluksesi erityistarpeisiin. Tämä antaa sinulle mahdollisuuden kapseloida monimutkainen logiikka ja edistää koodin uudelleenkäyttöä.

Esimerkki (Mukautettu middleware ominaisuuslipuille):

            // Mukautettu middleware ominaisuuksien ottamiseksi käyttöön/poistamiseksi käytöstä konfiguraatiotiedoston perusteella
const featureFlags = require('./config/feature-flags.json');

function featureFlagMiddleware(featureName) {
  return (req, res, next) => {
    if (featureFlags[featureName] === true) {
      next(); // Ominaisuus on käytössä, jatka
    } else {
      res.status(404).send('Ominaisuus ei saatavilla'); // Ominaisuus on poistettu käytöstä
    }
  };
}

// Esimerkkikäyttö
app.get('/new-feature', featureFlagMiddleware('newFeatureEnabled'), (req, res) => {
  res.send('Tämä on uusi ominaisuus!');
});

            

              
                Copy
              
            
          

Tämä esimerkki näyttää, kuinka mukautettua middlewarea käytetään tiettyjen reittien käyttöoikeuden hallintaan ominaisuuslippujen perusteella. Tämä antaa kehittäjille mahdollisuuden hallita ominaisuusjulkaisuja ilman uudelleenkäyttöönottoa tai koodin muuttamista, jota ei ole täysin tarkastettu, mikä on yleinen käytäntö ohjelmistokehityksessä.

Parhaat käytännöt ja huomioitavaa globaaleja sovelluksia varten

• Suorituskyky: Optimoi middlewaresi suorituskyvyn kannalta, erityisesti suuriliikenteisissä sovelluksissa. Minimoi suoritinintensiivisten operaatioiden käyttö. Harkitse välimuististrategioiden käyttöä.
• Skaalautuvuus: Suunnittele middlewaresi skaalautumaan horisontaalisesti. Älä säilytä istuntotietoja muistissa; käytä hajautettua välimuistia, kuten Redis tai Memcached.
• Tietoturva: Toteuta parhaat turvallisuuskäytännöt, mukaan lukien syötteen validointi, autentikointi, auktorisointi ja suojaus yleisiltä verkkohaavoittuvuuksilta. Tämä on kriittistä, erityisesti kansainvälisen yleisösi vuoksi.
• Ylläpidettävyys: Kirjoita selkeää, hyvin dokumentoitua ja modulaarista koodia. Käytä selkeitä nimeämiskäytäntöjä ja noudata yhtenäistä koodaustyyliä. Modulaarista middlewareesi helpottaaksesi ylläpitoa ja päivityksiä.
• Testattavuus: Kirjoita yksikkö- ja integraatiotestejä middlewarellesi varmistaaksesi sen oikean toiminnan ja mahdollisten virheiden varhaisen havaitsemisen. Testaa middlewareäsi erilaisissa ympäristöissä.
• Kansainvälistäminen (i18n) ja lokalisointi (l10n): Harkitse kansainvälistämistä ja lokalisointia, jos sovelluksesi tukee useita kieliä tai alueita. Tarjoa lokalisoituja virheilmoituksia, sisältöä ja muotoilua parantaaksesi käyttäjäkokemusta. Kirjastot kuten i18next voivat helpottaa i18n-toimia.
• Aikavyöhykkeet ja päivämäärä/aika-käsittely: Ota huomioon aikavyöhykkeet ja käsittele päivämäärä/aika-dataa huolellisesti, erityisesti globaalin yleisön kanssa työskennellessäsi. Käytä kirjastoja kuten Moment.js tai Luxon päivämäärä/aika-manipulointiin tai mieluummin uudempaa Javascriptin sisäänrakennettua Date-objektin käsittelyä aikavyöhyketietoisuudella. Tallenna päivämäärät/ajat UTC-muodossa tietokantaasi ja muunna ne käyttäjän paikalliseksi aikavyöhykkeeksi näyttäessäsi niitä.
• Valuutan käsittely: Jos sovelluksesi käsittelee taloustapahtumia, käsittele valuuttoja oikein. Käytä asianmukaista valuuttamuotoilua ja harkitse useiden valuuttojen tukemista. Varmista, että tietosi ylläpidetään johdonmukaisesti ja tarkasti.
• Lainsäädännöllinen ja säädöstenmukaisuus: Ole tietoinen eri maiden tai alueiden lainsäädännöllisistä ja säädöstenmukaisuusvaatimuksista (esim. GDPR, CCPA). Toteuta tarvittavat toimenpiteet näiden säännösten noudattamiseksi.
• Saavutettavuus: Varmista, että sovelluksesi on saavutettavissa vammaisille käyttäjille. Noudata saavutettavuusohjeita, kuten WCAG (Web Content Accessibility Guidelines).
• Seuranta ja hälytykset: Toteuta kattava seuranta ja hälytykset ongelmien nopeaksi havaitsemiseksi ja niihin reagoimiseksi. Valvo palvelimen suorituskykyä, sovellusvirheitä ja turvallisuusuhkia.

Yhteenveto

Edistyneiden middleware-mallien hallinta on välttämätöntä kestävien, turvallisten ja skaalautuvien Express.js-sovellusten rakentamisessa. Hyödyntämällä näitä malleja tehokkaasti voit luoda sovelluksia, jotka eivät ole vain toimivia, vaan myös ylläpidettäviä ja hyvin soveltuvia globaalille yleisölle. Muista priorisoida turvallisuus, suorituskyky ja ylläpidettävyys koko kehitysprosessin ajan. Huolellisella suunnittelulla ja toteutuksella voit hyödyntää Express.js middlewaren tehoa rakentaaksesi menestyksekkäitä verkkosovelluksia, jotka vastaavat käyttäjien tarpeisiin maailmanlaajuisesti.

Lisälukemista:

• Express.js Virallinen dokumentaatio
• npm Pakettiarkisto
• Helmet.js
• Passport.js
• Joi Validointikirjasto